home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / c / tiff_lib / source / tif_prin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-22  |  17.8 KB  |  392 lines
  1. #pragma warn -use
  2. static char     *sccsid = "@(#)TIFF/tif_print.c 1.23, Copyright (c) Sam Leffler, Dieter Linde, "__DATE__;
  3. #pragma warn .use
  4. /*
  5.  * Copyright (c) 1988, 1990 by Sam Leffler, Oct 8 1990
  6.  * All rights reserved.
  7.  *
  8.  * This file is provided for unrestricted use provided that this legend is included on all tape media and as a part of the
  9.  * software program in whole or part.  Users may copy, modify or distribute this file at will.
  10.  *
  11.  * TIFF Library.
  12.  *
  13.  * Directory Printing Support
  14.  */
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include "tiffio.h"
  18.  
  19. #define FIELD(tif, f)    TIFFFieldSet(tif, f)
  20.  
  21. static char    *ResponseUnitNames[] = {
  22.                 "#0",
  23.                 "10ths",
  24.                 "100ths",
  25.                 "1,000ths",
  26.                 "10,000ths",
  27.                 "100,000ths",
  28.         };
  29. static float    ResponseUnit[] = { 1.0, 0.1, 0.01, 0.001, 0.0001, 0.00001 };
  30.  
  31. #define    MAXRESPONSEUNIT    (sizeof(ResponseUnitNames) / sizeof(ResponseUnitNames[0]))
  32.  
  33. /****************************************************************************
  34.  * Print the contents of the current directory to the specified stdio file stream.
  35.  */
  36. void
  37. TIFFPrintDirectory(
  38.            TIFF     *tif,
  39.         FILE     *fd,
  40.         int     showstrips, 
  41.         int    showresponsecurve, 
  42.         int    showcolormap
  43.         )
  44. {
  45.         register TIFFDirectory    *td;
  46.         char             sep;
  47.         int             i;
  48.         long             n;
  49.         float             unit;
  50.  
  51.         fprintf(fd, "TIFF Directory at offset 0x%08x\n", tif->tif_diroff);
  52.         td = &tif->tif_dir;
  53.         if (FIELD(tif, FIELD_SUBFILETYPE)) {
  54.                 fputs("  Subfile Type..............:", fd);
  55.                 sep = ' ';
  56.                 if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) {
  57.                     fputc(sep, fd);
  58.                         fputs("reduced-resolution image", fd);
  59.                         sep = '/';
  60.                 }
  61.                 if (td->td_subfiletype & FILETYPE_PAGE) {
  62.                     fputc(sep, fd);
  63.                         fputs("multi-page document", fd);
  64.                         sep = '/';
  65.                 }
  66.                 if (td->td_subfiletype & FILETYPE_MASK) {
  67.                     fputc(sep, fd);
  68.                         fputs("transparency mask", fd);
  69.                 }
  70.                 fprintf(fd, " (%u = 0x%04x)\n", td->td_subfiletype, td->td_subfiletype);
  71.         }
  72.         if (FIELD(tif, FIELD_IMAGEDIMENSIONS)) {
  73.                 fprintf(fd, "  Image Width...............: %u\n", td->td_imagewidth);
  74.                 fprintf(fd, "  Image Length..............: %u\n", td->td_imagelength);
  75.         }
  76.         if (FIELD(tif, FIELD_RESOLUTION)) {
  77.                 fprintf(fd, "  Resolution................: %f, %f", td->td_xresolution, td->td_yresolution);
  78.                 if (FIELD(tif, FIELD_RESOLUTIONUNIT)) {
  79.                         switch (td->td_resolutionunit) {
  80.                             case RESUNIT_NONE:
  81.                                     fputs(" (unitless)", fd);
  82.                                     break;
  83.                             case RESUNIT_INCH:
  84.                                     fputs(" pixels/inch", fd);
  85.                                     break;
  86.                             case RESUNIT_CENTIMETER:
  87.                                     fputs(" pixels/cm", fd);
  88.                                     break;
  89.                             default:
  90.                                     fprintf(fd, " (unit %u = 0x%04x)", td->td_resolutionunit, td->td_resolutionunit);
  91.                                     break;
  92.                         }
  93.                 }
  94.                 fputc('\n', fd);
  95.         }
  96.         if (FIELD(tif, FIELD_POSITION))
  97.                    fprintf(fd, "  Position..................: %f, %f\n", td->td_xposition, td->td_yposition);
  98.         if (FIELD(tif, FIELD_BITSPERSAMPLE))
  99.                 fprintf(fd, "  Bits/Sample...............: %u\n", td->td_bitspersample);
  100.         if (FIELD(tif, FIELD_COMPRESSION)) {
  101.                 fputs("  Compression Scheme........: ", fd);
  102.                 switch (td->td_compression) {
  103.                     case COMPRESSION_NONE:
  104.                             fputs("none\n", fd);
  105.                             break;
  106.                     case COMPRESSION_CCITTRLE:
  107.                             fputs("CCITT modified Huffman encoding\n", fd);
  108.                             break;
  109.                     case COMPRESSION_CCITTFAX3:
  110.                             fputs("CCITT Group 3 facsimile encoding\n", fd);
  111.                             break;
  112.                     case COMPRESSION_CCITTFAX4:
  113.                             fputs("CCITT Group 4 facsimile encoding\n", fd);
  114.                             break;
  115.                     case COMPRESSION_CCITTRLEW:
  116.                             fputs("CCITT modified Huffman encoding w/ word alignment\n", fd);
  117.                             break;
  118.                     case COMPRESSION_PACKBITS:
  119.                             fputs("Macintosh PackBits encoding\n", fd);
  120.                             break;
  121.                     case COMPRESSION_THUNDERSCAN:
  122.                             fputs("ThunderScan 4-bit encoding\n", fd);
  123.                             break;
  124.                     case COMPRESSION_LZW:
  125.                             fputs("Lempel-Ziv & Welch encoding\n", fd);
  126.                             break;
  127.                     case COMPRESSION_PICIO:
  128.                             fputs("Pixar picio encoding\n", fd);
  129.                             break;
  130.                     case COMPRESSION_NEXT:
  131.                             fputs("NeXT 2-bit encoding\n", fd);
  132.                             break;
  133.             case COMPRESSION_SGIRLE:
  134.                 fputs("Silicon Graphics run-length encoding\n", fd);
  135.                 break;
  136.                     default:
  137.                             fprintf(fd, "%u (0x%04x)\n", td->td_compression, td->td_compression);
  138.                             break;
  139.                 }
  140.         }
  141.         if (FIELD(tif, FIELD_PHOTOMETRIC)) {
  142.                 fputs("  Photometric Interpretation: ", fd);
  143.                 switch (td->td_photometric) {
  144.                     case PHOTOMETRIC_MINISWHITE:
  145.                             fputs("min-is-white\n", fd);
  146.                             break;
  147.                     case PHOTOMETRIC_MINISBLACK:
  148.                             fputs("min-is-black\n", fd);
  149.                             break;
  150.                     case PHOTOMETRIC_RGB:
  151.                             fputs("RGB color\n", fd);
  152.                             break;
  153.                     case PHOTOMETRIC_PALETTE:
  154.                             fputs("palette color (RGB from colormap)\n", fd);
  155.                             break;
  156.                     case PHOTOMETRIC_MASK:
  157.                             fputs("transparency mask\n", fd);
  158.                             break;
  159.                     default:
  160.                             fprintf(fd, "%u (0x%04x)\n", td->td_photometric, td->td_photometric);
  161.                             break;
  162.                 }
  163.         }
  164.         if (FIELD(tif, FIELD_MATTEING))
  165.                 fprintf(fd, "  Matteing..................: %s\n", td->td_matteing ? "pre-multiplied with alpha channel" : "none");
  166.         if (FIELD(tif, FIELD_THRESHHOLDING)) {
  167.                 fputs("  Thresholding..............: ", fd);
  168.                 switch (td->td_threshholding) {
  169.                     case THRESHHOLD_BILEVEL:
  170.                             fputs("bilevel art scan\n", fd);
  171.                             break;
  172.                     case THRESHHOLD_HALFTONE:
  173.                             fputs("halftone or dithered scan\n", fd);
  174.                             break;
  175.                     case THRESHHOLD_ERRORDIFFUSE:
  176.                             fputs("error diffused\n", fd);
  177.                             break;
  178.                     default:
  179.                             fprintf(fd, "%u (0x%04x)\n", td->td_threshholding, td->td_threshholding);
  180.                             break;
  181.                 }
  182.         }
  183.         if (FIELD(tif, FIELD_FILLORDER)) {
  184.                 fputs("  Fillorder.................: ", fd);
  185.                 switch (td->td_fillorder) {
  186.                     case FILLORDER_MSB2LSB:
  187.                             fputs("msb-to-lsb\n", fd);
  188.                             break;
  189.                     case FILLORDER_LSB2MSB:
  190.                             fputs("lsb-to-msb\n", fd);
  191.                             break;
  192.                     default:
  193.                             fprintf(fd, "%u (0x%04x)\n", td->td_fillorder, td->td_fillorder);
  194.                             break;
  195.                 }
  196.         }
  197.         if (FIELD(tif, FIELD_PREDICTOR)) {
  198.                 fputs("  Predictor.................: ", fd);
  199.                 switch (td->td_predictor) {
  200.                     case 1:
  201.                             fputs("none\n", fd);
  202.                             break;
  203.                     case 2:
  204.                             fputs("horizontal differencing\n", fd);
  205.                             break;
  206.                     default:
  207.                             fprintf(fd, "%u (0x%04x)\n", td->td_predictor, td->td_predictor);
  208.                             break;
  209.                 }
  210.         }
  211.         if (FIELD(tif, FIELD_ARTIST))
  212.                 fprintf(fd, "  Artist....................: %s\n", td->td_artist);
  213.         if (FIELD(tif, FIELD_DATETIME))
  214.                 fprintf(fd, "  Date & Time...............: %s\n", td->td_datetime);
  215.         if (FIELD(tif, FIELD_HOSTCOMPUTER))
  216.                 fprintf(fd, "  Host Computer.............: %s\n", td->td_hostcomputer);
  217.         if (FIELD(tif, FIELD_SOFTWARE))
  218.                 fprintf(fd, "  Software..................: %s\n", td->td_software);
  219.         if (FIELD(tif, FIELD_DOCUMENTNAME))
  220.                 fprintf(fd, "  Document Name.............: %s\n", td->td_documentname);
  221.         if (FIELD(tif, FIELD_IMAGEDESCRIPTION))
  222.                 fprintf(fd, "  Image Description.........: %s\n", td->td_imagedescription);
  223.         if (FIELD(tif, FIELD_MAKE))
  224.                 fprintf(fd, "  Make......................: %s\n", td->td_make);
  225.         if (FIELD(tif, FIELD_MODEL))
  226.                 fprintf(fd, "  Model.....................: %s\n", td->td_model);
  227.         if (FIELD(tif, FIELD_ORIENTATION)) {
  228.                 fputs("  Orientation...............: ", fd);
  229.                 switch (td->td_orientation) {
  230.                     case ORIENTATION_TOPLEFT:
  231.                             fputs("row 0 top, col 0 lhs\n", fd);
  232.                             break;
  233.                     case ORIENTATION_TOPRIGHT:
  234.                             fputs("row 0 top, col 0 rhs\n", fd);
  235.                             break;
  236.                     case ORIENTATION_BOTRIGHT:
  237.                             fputs("row 0 bottom, col 0 rhs\n", fd);
  238.                             break;
  239.                     case ORIENTATION_BOTLEFT:
  240.                             fputs("row 0 bottom, col 0 lhs\n", fd);
  241.                             break;
  242.                     case ORIENTATION_LEFTTOP:
  243.                             fputs("row 0 lhs, col 0 top\n", fd);
  244.                             break;
  245.                     case ORIENTATION_RIGHTTOP:
  246.                             fputs("row 0 rhs, col 0 top\n", fd);
  247.                             break;
  248.                     case ORIENTATION_RIGHTBOT:
  249.                             fputs("row 0 rhs, col 0 bottom\n", fd);
  250.                             break;
  251.                     case ORIENTATION_LEFTBOT:
  252.                             fputs("row 0 lhs, col 0 bottom\n", fd);
  253.                             break;
  254.                     default:
  255.                             fprintf(fd, "%u (0x%04x)\n", td->td_orientation, td->td_orientation);
  256.                             break;
  257.                 }
  258.         }
  259.         if (FIELD(tif, FIELD_SAMPLESPERPIXEL))
  260.                 fprintf(fd, "  Samples/Pixel.............: %u\n", td->td_samplesperpixel);
  261.         if (FIELD(tif, FIELD_ROWSPERSTRIP)) {
  262.                 fputs("  Rows/Strip................: ", fd);
  263.                 if (td->td_rowsperstrip == 0xffffffffL)
  264.                         fputs("(infinite)\n", fd);
  265.                 else
  266.                         fprintf(fd, "%u\n", td->td_rowsperstrip);
  267.         }
  268.         if (FIELD(tif, FIELD_MINSAMPLEVALUE))
  269.                 fprintf(fd, "  Minimum Sample Value......: %u\n", td->td_minsamplevalue);
  270.         if (FIELD(tif, FIELD_MAXSAMPLEVALUE))
  271.                 fprintf(fd, "  Maximum Sample Value......: %u\n", td->td_maxsamplevalue);
  272.         if (FIELD(tif, FIELD_PLANARCONFIG)) {
  273.                 fputs("  Planar Configuration......: ", fd);
  274.                 switch (td->td_planarconfig) {
  275.                     case PLANARCONFIG_CONTIG:
  276.                             fputs("single image plane\n", fd);
  277.                             break;
  278.                     case PLANARCONFIG_SEPARATE:
  279.                             fputs("separate image planes\n", fd);
  280.                             break;
  281.                     default:
  282.                             fprintf(fd, "%u (0x%04x)\n", td->td_planarconfig, td->td_planarconfig);
  283.                             break;
  284.                 }
  285.         }
  286.         if (FIELD(tif, FIELD_PAGENAME))
  287.                 fprintf(fd, "  Page Name.................: %s\n", td->td_pagename);
  288.         if (FIELD(tif, FIELD_GRAYRESPONSEUNIT)) {
  289.                 fputs("  Gray Response Unit........: ", fd);
  290.                 if (td->td_grayresponseunit < MAXRESPONSEUNIT)
  291.                         fprintf(fd, "%s\n", ResponseUnitNames[td->td_grayresponseunit]);
  292.                 else
  293.                         fprintf(fd, "%u (0x%04x)\n", td->td_grayresponseunit, td->td_grayresponseunit);
  294.         }
  295.         if (FIELD(tif, FIELD_GRAYRESPONSECURVE)) {
  296.                 fputs("  Gray Response Curve.......: ", fd);
  297.                 if (showresponsecurve) {
  298.                         fputc('\n', fd);
  299.                         unit = ResponseUnit[td->td_grayresponseunit];
  300.                         n = 1L << td->td_bitspersample;
  301.                         for (i = 0; i < n; i++)
  302.                                 fprintf(fd, "    %2d: %f (%u)\n", i, td->td_grayresponsecurve[i] * unit, td->td_grayresponsecurve[i]);
  303.                 } 
  304.                 else
  305.                         fputs("(present)\n", fd);
  306.         }
  307.         if (FIELD(tif, FIELD_GROUP3OPTIONS)) {
  308.                 fputs("  Group 3 Options...........:", fd);
  309.                 sep = ' ';
  310.                 if (td->td_group3options & GROUP3OPT_2DENCODING) {
  311.                     fputc(sep, fd);
  312.                            fputs("2-d encoding", fd);
  313.                            sep = '+';
  314.                    }
  315.                 if (td->td_group3options & GROUP3OPT_FILLBITS) {
  316.                     fputc(sep, fd);
  317.                         fputs("EOL padding", fd);
  318.                         sep = '+';
  319.                   }
  320.                 if (td->td_group3options & GROUP3OPT_UNCOMPRESSED) {
  321.                     fputc(sep, fd);
  322.                         fputs("no compression", fd);
  323.                 }
  324.                 fprintf(fd, " (%lu = 0x%08lx)\n", td->td_group3options, td->td_group3options);
  325.         }
  326.         if (FIELD(tif, FIELD_CLEANFAXDATA)) {
  327.                 fputs("  Fax Data..................: ", fd);
  328.                 switch (td->td_cleanfaxdata) {
  329.                     case CLEANFAXDATA_CLEAN:
  330.                             fputs("clean\n", fd);
  331.                             break;
  332.                     case CLEANFAXDATA_REGENERATED:
  333.                             fputs("receiver regenerated\n", fd);
  334.                             break;
  335.                     case CLEANFAXDATA_UNCLEAN:
  336.                             fputs("uncorrected errors\n", fd);
  337.                             break;
  338.                     default:
  339.                             fprintf(fd, "(%u = 0x%04x)\n", td->td_cleanfaxdata, td->td_cleanfaxdata);
  340.                             break;
  341.                 }
  342.         }
  343.         if (FIELD(tif, FIELD_BADFAXLINES))
  344.                 fprintf(fd, "  Bad Fax Lines.............: %lu\n", td->td_badfaxlines);
  345.         if (FIELD(tif, FIELD_BADFAXRUN))
  346.                 fprintf(fd, "  Consecutive Bad Fax Lines.: %u\n", td->td_badfaxrun);
  347.         if (FIELD(tif, FIELD_GROUP4OPTIONS))
  348.                 fprintf(fd, "  Group 4 Options...........: %lu (0x%08lx)\n", td->td_group4options, td->td_group4options);
  349.         if (FIELD(tif, FIELD_PAGENUMBER))
  350.                 fprintf(fd, "  Page Number...............: %u-%u\n", td->td_pagenumber[0], td->td_pagenumber[1]);
  351.         if (FIELD(tif, FIELD_COLORRESPONSEUNIT)) {
  352.                 fputs("  Color Response Unit.......: ", fd);
  353.                 if (td->td_colorresponseunit < MAXRESPONSEUNIT)
  354.                         fprintf(fd, "%s\n", ResponseUnitNames[td->td_colorresponseunit]);
  355.                 else
  356.                         fprintf(fd, "%u (0x%04x)\n", td->td_colorresponseunit, td->td_colorresponseunit);
  357.         }
  358.         if (FIELD(tif, FIELD_COLORMAP)) {
  359.                 fputs("  Color Map.................: ", fd);
  360.                 if (showcolormap) {
  361.                         fputc('\n', fd);
  362.                         n = 1L << td->td_bitspersample;
  363.                         for (i = 0; i < n; i++)
  364.                                 fprintf(fd, "   %5d: %5u %5u %5u\n", i, td->td_redcolormap[i], td->td_greencolormap[i], td->td_bluecolormap[i]);
  365.                 } 
  366.                 else
  367.                         fputs("(present)\n", fd);
  368.         }
  369.         if (FIELD(tif, FIELD_COLORRESPONSECURVE)) {
  370.                 fputs("  Color Response Curve......: ", fd);
  371.                 if (showresponsecurve) {
  372.                         fputc('\n', fd);
  373.                         unit = ResponseUnit[td->td_colorresponseunit];
  374.                         n = 1L << td->td_bitspersample;
  375.                         for (i = 0; i < n; i++)
  376.                                 fprintf(fd, "    %2d: %6.4f %6.4f %6.4f\n", i, td->td_redresponsecurve[i] * unit, td->td_greenresponsecurve[i] * unit, td->td_blueresponsecurve[i] * unit);
  377.                 } 
  378.                 else
  379.                         fputs("(present)\n", fd);
  380.         }
  381.         if (showstrips && FIELD(tif, FIELD_STRIPOFFSETS)) {
  382.             char    s[20];
  383.  
  384.                 fprintf(fd, "  %lu Strips", td->td_nstrips);
  385.                 for (i = 0; i < 19 - (int)strlen(ltoa(td->td_nstrips, s, 10)); i++)
  386.                     fputc('.', fd);
  387.                 fputs(":\n", fd);
  388.                 for (i = 0; i < td->td_nstrips; i++)
  389.                         fprintf(fd, "    %3d: [%8lu, %8lu]\n", i, td->td_stripoffset[i], td->td_stripbytecount[i]);
  390.         }
  391. }
  392.